function 计算题_四则运算(nodeList/*（要求元素是对点击有反应的那些）*/, 标记正确的 = true) { return [...nodeList].map(el => [el, el.innerText.replace('=', '==')]).filter(([el, text, _res]) => (_res = eval(text), 标记正确的 ? _res : !_res)) }


Object.defineProperties(Array.prototype, Array._prototypePlus = { _asStrs: { get: toTexts }, _asObjStr: { get() { return `{${this.join(',')}}` } }, _nes: { get() { return this.filter(_ => _ !== '') } }, 末: { get() { return this.at(-1) } } })
Object.defineProperties(NodeList.prototype, NodeList._prototypePlus = { find: { value: Array.prototype.find }, findIndex: { value: Array.prototype.findIndex }, map: { value: Array.prototype.map }, filter: { value: Array.prototype.filter }, _asStrs: Array._prototypePlus._asStrs, _nee: { get() { return this.filter(el => el.innerText !== '') } } })
Object.defineProperties(HTMLCollection.prototype, NodeList._prototypePlus)
Object.defineProperties(String.prototype, { 散列: { get: hashCode }, _asKV: { get() { return this.replaceAll('"', '\\"').replace(/^\s*(.+?):\s*(.*)[^]*$/, '"$1":"$2"') } }, _asObjStr: { get() { return `{${this}}` } }, _asObj: { get() { return JSON.parse(this) } }, _asKVObj: { get() { return this._asKV._asObjStr._asObj } } })
Object.defineProperties(window, { 随机: { get() { return Array.isArray(window.关于) ? (window.关于_ = window.关于, delete window.关于, 随机0到n(window.关于_.length - 1)) : 随机0或1() } } })
Object.defineProperties(HTMLElement.prototype, { _qS: { value: _qS } })

function _qS(selector) { return this.matches(selector) ? this : this.querySelector(selector) }

function $form__label(元素) { return 选相应(元素, 'form', 'label') }
function $div__select$(元素) { return 选相应们(元素, '', 'select') }
function $div__option$(元素) { return 选相应们(元素, '', ':is(option,li>a,li)') }
function $div__input(元素) { return 选相应(元素, '', 'input') }
function $h5__li_a$(元素) { return 选相应们(元素, 'h5', 'li>a') }
function $a(元素) { return 选相应(元素, 'li', 'a') }

function 找文本含于(元素们, 关键词) { return 元素们.find(_ => 组化(关键词).find(任一关键词 => 文本判等(_.innerText, 任一关键词))) }
function 找文本同于(元素们, 答案) { return 元素们.find(_ => 组化(答案).find(任一答案 => _.innerText === 任一答案)) }
function 文本判等(文本, 关键词) { return 是正则(关键词) ? 关键词.test(文本) : 文本.includes(关键词) }
function toText(元素) { return 元素.innerText }
function toTexts() { return this.map(toText) }

function 是正则(_) { return _ instanceof RegExp }
function 是元素(_) { return _ instanceof Element }
function 是字串(_) { return typeof _ === 'string' }
function 是函数(_) { return typeof _ === 'function' }


function 选相应(元素, 父级选择器, 目标选择器) { return _选旁元素(元素, 父级选择器, 目标选择器, false) }
function 选相应们(元素, 父级选择器, 目标选择器) { return _选旁元素(元素, 父级选择器, 目标选择器, true) }
function _选旁元素(起始元素, 父级选择器, 目标选择器, 都选) { 父级选择器 ||= `:not(${起始元素.localName})`; return 起始元素.closest(父级选择器)[`querySelector${都选 ? 'All' : ''}`](目标选择器) }

function 点击(元素s) { 组化(元素s).forEach(_ => { if (!_) return; _ = [_[0], _].find(是元素); _.hasOwnProperty('selected') ? _.selected = true : _.click() }) }

function 组化(_) { return Array.isArray(_) ? _ : [_] }
function 反组化(_) { return Array.isArray(_[0]) ? _[0] : _ }
function 触发(元素, 事件名 = 'focus', detail) { return 元素.dispatchEvent(new CustomEvent(事件名, { bubbles: true, detail })) }
function 聚焦(元素) { 触发(元素, 'focus'); return 元素 }
function 填写(元素, 文本) { 元素.value = 文本; 触发(元素, 'input') }


function 随机取(数组 = window.关于 ||= [0]) { return 数组[随机0到n(数组.length - 1)] }
function 随机0或1() { return 随机0到n(1) }
function 随机0到n(n) { return Math.floor(Math.random() * (Math.floor(n) + 1)) }
function 范围(起, 终 = 起) { return Array(Math.abs(范围._ = Math.floor(终 + (Math.sign(终) || 1) * 1) - Math.ceil(起))).fill().map((_, i) => 起 + Math.sign(范围._) * i) }

function 日期(...数组) { 数组 = 反组化(数组); --数组[1]; return Object.assign(数组 = new Date(...数组).toISOString().replace(/T.*/, '').split('-'), { toString: 日期.转文本 }, 转置成型([...'年月日'], 数组)) }
日期.转文本 = function (格式) { const YMD = 转置成型(['YYYY, MM, DD'.split(', '), this]); return 日期.转文本.格式[格式]?.replace(/\w+/g, ymd => YMD[ymd]) }
日期.转文本.格式 = { undefined: 'YYYY-MM-DD', 美式: 'MM/DD/YYYY' }
Object.defineProperties(日期, { 中国: { get() { return new Date(new Date().toISOString().replace('Z', '') + '-0800').toISOString().replace('T', ' ').replace(/\.\d+Z/g, '') } } })
日期.时间差 = (t1, t2, 计天 = false) => {
  t1 = new Date(t1)
  t2 = new Date(t2)
  const 日期 = new Date(Math.abs(t2 - t1))
  const 天 = 日期.getUTCDate() - 1
  const 时 = 日期.getUTCHours()
  const 分 = 日期.getUTCMinutes()
  const 秒 = 日期.getUTCSeconds()
  return [...计天 ? [天] : [], 时, 分, 秒].map(单位 => 单位.toString().padStart(2, 0)).join(':')
}


function 转置(数组) { return 数组[0].map((_, 列索引) => 数组.map(行 => 行[列索引])) }
function 转置成型(数组a, 数组b) { return Object.fromEntries(转置([数组a, 数组b])) }

function 提取键(对象, 键们) { return 组化(键们).map(键 => 对象[键]) }
function 数同(a, b) { return typeof a === 'number' ? a == b : 0 === a?.localeCompare?.(b, undefined, { numeric: true }) }


function 切样式(样式, { id, 开, target } = {}) { id ??= 样式.散列; 切样式.目标 = document.getElementById(id); if (开 && 切样式.目标) return; if (!开 || 切样式.目标) return (target && (target.checked = false), 切样式.目标?.remove()); document.head.insertAdjacentHTML('beforeend', `<style${id ? ` id=${id}` : ''}>${样式}</style>`); return id && document.getElementById(id) }
function 字串化(对象, 缩进空格数) { return 是字串(对象) ? 对象 : JSON.stringify(对象, null, 缩进空格数) }


function 监察(元素选择器, 回调, 挂载元素) {
  if (!元素选择器) 元素选择器 = '*'
  if (是函数(元素选择器)) [元素选择器, 回调] = ['*', 元素选择器]
  if (!是元素(挂载元素)) 挂载元素 = document.querySelector(元素选择器) ?? document.body
  let 元素 = 挂载元素._qS(元素选择器)
  let 目的 = 元素 && 回调({ target: 元素 }, 元素选择器)
  if (目的?.done ?? 目的) return 目的
  return new Promise((resolve, reject) => {
    new MutationObserver(async function (变动们) {
      ++监察.组次
      // console.log('监察.组次:', ++监察.组次)
      for (const 变动 of 变动们) {
        try {
          目的 = await 回调.call(this, 变动, 元素选择器)
          if (目的?.done ?? 目的) {
            this.disconnect()
            // console.log('变动：', 变动)
            resolve(目的)
            break
          }
        } catch (错误) {
          console.error(错误, 变动, 变动们)
          this.disconnect()
        }
      }
    }).observe(元素 ?? 挂载元素, { childList: true, attributes: true, subtree: true, characterData: true })
  })
}
监察.组次 = 0


function 试行(函数, ...参数) { try { return 函数.apply(this, 参数) } catch (错误) { /* console.info(错误) */ } }
function 获取网址参数(键) { return new URL(location).searchParams.get(键) }

Object.entries({ 触发, 日期, 监察 }).forEach(([k, v]) => unsafeWindow[k] = v)

/* 为下一个文件准备的换行不能删 */